/**
 *
 */
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @endpointRule = '';
  
  checkConfig(config);
  @endpoint = getEndpoint('dt-oc-info', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }
  
  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}

model GetBeneficialInfoRequest {
  oneCompanyId?: string(name='OneCompanyId'),
}

model GetBeneficialInfoResponseBody = {
  code?: int32(name='Code'),
  data?: [  map[string]any ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetBeneficialInfoResponse = {
  headers: map[string]string(name='headers'),
  body: GetBeneficialInfoResponseBody(name='body'),
}

async function getBeneficialInfoWithOptions(request: GetBeneficialInfoRequest, runtime: Util.RuntimeOptions): GetBeneficialInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.oneCompanyId)) {
    query['OneCompanyId'] = request.oneCompanyId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBeneficialInfo',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBeneficialInfo(request: GetBeneficialInfoRequest): GetBeneficialInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBeneficialInfoWithOptions(request, runtime);
}

model GetBiddingRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetBiddingResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetBiddingResponse = {
  headers: map[string]string(name='headers'),
  body: GetBiddingResponseBody(name='body'),
}

async function getBiddingWithOptions(request: GetBiddingRequest, runtime: Util.RuntimeOptions): GetBiddingResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBidding',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBidding(request: GetBiddingRequest): GetBiddingResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBiddingWithOptions(request, runtime);
}

model GetBranchesThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetBranchesThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetBranchesThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetBranchesThreeResponseBody(name='body'),
}

async function getBranchesThreeWithOptions(request: GetBranchesThreeRequest, runtime: Util.RuntimeOptions): GetBranchesThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBranchesThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBranchesThree(request: GetBranchesThreeRequest): GetBranchesThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBranchesThreeWithOptions(request, runtime);
}

model GetCheckupRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCheckupResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCheckupResponse = {
  headers: map[string]string(name='headers'),
  body: GetCheckupResponseBody(name='body'),
}

async function getCheckupWithOptions(request: GetCheckupRequest, runtime: Util.RuntimeOptions): GetCheckupResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCheckup',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCheckup(request: GetCheckupRequest): GetCheckupResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCheckupWithOptions(request, runtime);
}

model GetClearAccountRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetClearAccountResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetClearAccountResponse = {
  headers: map[string]string(name='headers'),
  body: GetClearAccountResponseBody(name='body'),
}

async function getClearAccountWithOptions(request: GetClearAccountRequest, runtime: Util.RuntimeOptions): GetClearAccountResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetClearAccount',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getClearAccount(request: GetClearAccountRequest): GetClearAccountResponse {
  var runtime = new Util.RuntimeOptions{};
  return getClearAccountWithOptions(request, runtime);
}

model GetClearAccountThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetClearAccountThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetClearAccountThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetClearAccountThreeResponseBody(name='body'),
}

async function getClearAccountThreeWithOptions(request: GetClearAccountThreeRequest, runtime: Util.RuntimeOptions): GetClearAccountThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetClearAccountThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getClearAccountThree(request: GetClearAccountThreeRequest): GetClearAccountThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getClearAccountThreeWithOptions(request, runtime);
}

model GetCompanyChangeThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCompanyChangeThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCompanyChangeThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetCompanyChangeThreeResponseBody(name='body'),
}

async function getCompanyChangeThreeWithOptions(request: GetCompanyChangeThreeRequest, runtime: Util.RuntimeOptions): GetCompanyChangeThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCompanyChangeThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCompanyChangeThree(request: GetCompanyChangeThreeRequest): GetCompanyChangeThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCompanyChangeThreeWithOptions(request, runtime);
}

model GetCompanyCourtAnnouncementThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCompanyCourtAnnouncementThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCompanyCourtAnnouncementThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetCompanyCourtAnnouncementThreeResponseBody(name='body'),
}

async function getCompanyCourtAnnouncementThreeWithOptions(request: GetCompanyCourtAnnouncementThreeRequest, runtime: Util.RuntimeOptions): GetCompanyCourtAnnouncementThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCompanyCourtAnnouncementThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCompanyCourtAnnouncementThree(request: GetCompanyCourtAnnouncementThreeRequest): GetCompanyCourtAnnouncementThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCompanyCourtAnnouncementThreeWithOptions(request, runtime);
}

model GetCompanyEmployeesThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCompanyEmployeesThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCompanyEmployeesThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetCompanyEmployeesThreeResponseBody(name='body'),
}

async function getCompanyEmployeesThreeWithOptions(request: GetCompanyEmployeesThreeRequest, runtime: Util.RuntimeOptions): GetCompanyEmployeesThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCompanyEmployeesThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCompanyEmployeesThree(request: GetCompanyEmployeesThreeRequest): GetCompanyEmployeesThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCompanyEmployeesThreeWithOptions(request, runtime);
}

model GetCompanyEquityPledgeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCompanyEquityPledgeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCompanyEquityPledgeResponse = {
  headers: map[string]string(name='headers'),
  body: GetCompanyEquityPledgeResponseBody(name='body'),
}

async function getCompanyEquityPledgeWithOptions(request: GetCompanyEquityPledgeRequest, runtime: Util.RuntimeOptions): GetCompanyEquityPledgeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCompanyEquityPledge',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCompanyEquityPledge(request: GetCompanyEquityPledgeRequest): GetCompanyEquityPledgeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCompanyEquityPledgeWithOptions(request, runtime);
}

model GetCompanyInvestmentRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCompanyInvestmentResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCompanyInvestmentResponse = {
  headers: map[string]string(name='headers'),
  body: GetCompanyInvestmentResponseBody(name='body'),
}

async function getCompanyInvestmentWithOptions(request: GetCompanyInvestmentRequest, runtime: Util.RuntimeOptions): GetCompanyInvestmentResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCompanyInvestment',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCompanyInvestment(request: GetCompanyInvestmentRequest): GetCompanyInvestmentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCompanyInvestmentWithOptions(request, runtime);
}

model GetCompanyJudgmentDocumentRequest {
  countSqlId?: int32(name='CountSqlId'),
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCompanyJudgmentDocumentResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCompanyJudgmentDocumentResponse = {
  headers: map[string]string(name='headers'),
  body: GetCompanyJudgmentDocumentResponseBody(name='body'),
}

async function getCompanyJudgmentDocumentWithOptions(request: GetCompanyJudgmentDocumentRequest, runtime: Util.RuntimeOptions): GetCompanyJudgmentDocumentResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.countSqlId)) {
    query['CountSqlId'] = request.countSqlId;
  }
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCompanyJudgmentDocument',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCompanyJudgmentDocument(request: GetCompanyJudgmentDocumentRequest): GetCompanyJudgmentDocumentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCompanyJudgmentDocumentWithOptions(request, runtime);
}

model GetCompanyJudgmentDocumentThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCompanyJudgmentDocumentThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCompanyJudgmentDocumentThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetCompanyJudgmentDocumentThreeResponseBody(name='body'),
}

async function getCompanyJudgmentDocumentThreeWithOptions(request: GetCompanyJudgmentDocumentThreeRequest, runtime: Util.RuntimeOptions): GetCompanyJudgmentDocumentThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCompanyJudgmentDocumentThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCompanyJudgmentDocumentThree(request: GetCompanyJudgmentDocumentThreeRequest): GetCompanyJudgmentDocumentThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCompanyJudgmentDocumentThreeWithOptions(request, runtime);
}

model GetCompanyLegalCaseThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCompanyLegalCaseThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCompanyLegalCaseThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetCompanyLegalCaseThreeResponseBody(name='body'),
}

async function getCompanyLegalCaseThreeWithOptions(request: GetCompanyLegalCaseThreeRequest, runtime: Util.RuntimeOptions): GetCompanyLegalCaseThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCompanyLegalCaseThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCompanyLegalCaseThree(request: GetCompanyLegalCaseThreeRequest): GetCompanyLegalCaseThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCompanyLegalCaseThreeWithOptions(request, runtime);
}

model GetCompanyLegalExecutedPersonThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCompanyLegalExecutedPersonThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCompanyLegalExecutedPersonThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetCompanyLegalExecutedPersonThreeResponseBody(name='body'),
}

async function getCompanyLegalExecutedPersonThreeWithOptions(request: GetCompanyLegalExecutedPersonThreeRequest, runtime: Util.RuntimeOptions): GetCompanyLegalExecutedPersonThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCompanyLegalExecutedPersonThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCompanyLegalExecutedPersonThree(request: GetCompanyLegalExecutedPersonThreeRequest): GetCompanyLegalExecutedPersonThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCompanyLegalExecutedPersonThreeWithOptions(request, runtime);
}

model GetCompanyLegalExecutionsThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCompanyLegalExecutionsThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCompanyLegalExecutionsThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetCompanyLegalExecutionsThreeResponseBody(name='body'),
}

async function getCompanyLegalExecutionsThreeWithOptions(request: GetCompanyLegalExecutionsThreeRequest, runtime: Util.RuntimeOptions): GetCompanyLegalExecutionsThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCompanyLegalExecutionsThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCompanyLegalExecutionsThree(request: GetCompanyLegalExecutionsThreeRequest): GetCompanyLegalExecutionsThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCompanyLegalExecutionsThreeWithOptions(request, runtime);
}

model GetCompanyPartnersListRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCompanyPartnersListResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCompanyPartnersListResponse = {
  headers: map[string]string(name='headers'),
  body: GetCompanyPartnersListResponseBody(name='body'),
}

async function getCompanyPartnersListWithOptions(request: GetCompanyPartnersListRequest, runtime: Util.RuntimeOptions): GetCompanyPartnersListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCompanyPartnersList',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCompanyPartnersList(request: GetCompanyPartnersListRequest): GetCompanyPartnersListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCompanyPartnersListWithOptions(request, runtime);
}

model GetCompanyPartnersListThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCompanyPartnersListThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCompanyPartnersListThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetCompanyPartnersListThreeResponseBody(name='body'),
}

async function getCompanyPartnersListThreeWithOptions(request: GetCompanyPartnersListThreeRequest, runtime: Util.RuntimeOptions): GetCompanyPartnersListThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCompanyPartnersListThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCompanyPartnersListThree(request: GetCompanyPartnersListThreeRequest): GetCompanyPartnersListThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCompanyPartnersListThreeWithOptions(request, runtime);
}

model GetCompanyProfileRequest {
  companyIdKeyParam?: map[string]any(name='CompanyIdKeyParam'),
  sqlId?: int32(name='SqlId'),
}

model GetCompanyProfileShrinkRequest {
  companyIdKeyParamShrink?: string(name='CompanyIdKeyParam'),
  sqlId?: int32(name='SqlId'),
}

model GetCompanyProfileResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCompanyProfileResponse = {
  headers: map[string]string(name='headers'),
  body: GetCompanyProfileResponseBody(name='body'),
}

async function getCompanyProfileWithOptions(tmpReq: GetCompanyProfileRequest, runtime: Util.RuntimeOptions): GetCompanyProfileResponse {
  Util.validateModel(tmpReq);
  var request = new GetCompanyProfileShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.companyIdKeyParam)) {
    request.companyIdKeyParamShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.companyIdKeyParam, 'CompanyIdKeyParam', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.companyIdKeyParamShrink)) {
    query['CompanyIdKeyParam'] = request.companyIdKeyParamShrink;
  }
  if (!Util.isUnset(request.sqlId)) {
    query['SqlId'] = request.sqlId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCompanyProfile',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCompanyProfile(request: GetCompanyProfileRequest): GetCompanyProfileResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCompanyProfileWithOptions(request, runtime);
}

model GetCompanyProfileCallbackRequest {
  companyGroupId?: string(name='CompanyGroupId'),
  companyQueryUrl?: string(name='CompanyQueryUrl'),
  featureCallbackUrl?: string(name='FeatureCallbackUrl'),
  profileCallbackUrl?: string(name='ProfileCallbackUrl'),
}

model GetCompanyProfileCallbackResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
}

model GetCompanyProfileCallbackResponse = {
  headers: map[string]string(name='headers'),
  body: GetCompanyProfileCallbackResponseBody(name='body'),
}

async function getCompanyProfileCallbackWithOptions(request: GetCompanyProfileCallbackRequest, runtime: Util.RuntimeOptions): GetCompanyProfileCallbackResponse {
  Util.validateModel(request);
  var body : map[string]any= {};
  if (!Util.isUnset(request.companyGroupId)) {
    body['CompanyGroupId'] = request.companyGroupId;
  }
  if (!Util.isUnset(request.companyQueryUrl)) {
    body['CompanyQueryUrl'] = request.companyQueryUrl;
  }
  if (!Util.isUnset(request.featureCallbackUrl)) {
    body['FeatureCallbackUrl'] = request.featureCallbackUrl;
  }
  if (!Util.isUnset(request.profileCallbackUrl)) {
    body['ProfileCallbackUrl'] = request.profileCallbackUrl;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetCompanyProfileCallback',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCompanyProfileCallback(request: GetCompanyProfileCallbackRequest): GetCompanyProfileCallbackResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCompanyProfileCallbackWithOptions(request, runtime);
}

model GetCompanyProfileThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCompanyProfileThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCompanyProfileThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetCompanyProfileThreeResponseBody(name='body'),
}

async function getCompanyProfileThreeWithOptions(request: GetCompanyProfileThreeRequest, runtime: Util.RuntimeOptions): GetCompanyProfileThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCompanyProfileThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCompanyProfileThree(request: GetCompanyProfileThreeRequest): GetCompanyProfileThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCompanyProfileThreeWithOptions(request, runtime);
}

model GetCompetitorInfoRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCompetitorInfoResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCompetitorInfoResponse = {
  headers: map[string]string(name='headers'),
  body: GetCompetitorInfoResponseBody(name='body'),
}

async function getCompetitorInfoWithOptions(request: GetCompetitorInfoRequest, runtime: Util.RuntimeOptions): GetCompetitorInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCompetitorInfo',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCompetitorInfo(request: GetCompetitorInfoRequest): GetCompetitorInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCompetitorInfoWithOptions(request, runtime);
}

model GetContactRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetContactResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetContactResponse = {
  headers: map[string]string(name='headers'),
  body: GetContactResponseBody(name='body'),
}

async function getContactWithOptions(request: GetContactRequest, runtime: Util.RuntimeOptions): GetContactResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetContact',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getContact(request: GetContactRequest): GetContactResponse {
  var runtime = new Util.RuntimeOptions{};
  return getContactWithOptions(request, runtime);
}

model GetCopyrightRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCopyrightResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCopyrightResponse = {
  headers: map[string]string(name='headers'),
  body: GetCopyrightResponseBody(name='body'),
}

async function getCopyrightWithOptions(request: GetCopyrightRequest, runtime: Util.RuntimeOptions): GetCopyrightResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCopyright',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCopyright(request: GetCopyrightRequest): GetCopyrightResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCopyrightWithOptions(request, runtime);
}

model GetCoreTeamRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCoreTeamResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCoreTeamResponse = {
  headers: map[string]string(name='headers'),
  body: GetCoreTeamResponseBody(name='body'),
}

async function getCoreTeamWithOptions(request: GetCoreTeamRequest, runtime: Util.RuntimeOptions): GetCoreTeamResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCoreTeam',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCoreTeam(request: GetCoreTeamRequest): GetCoreTeamResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCoreTeamWithOptions(request, runtime);
}

model GetCorpFinanceRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCorpFinanceResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCorpFinanceResponse = {
  headers: map[string]string(name='headers'),
  body: GetCorpFinanceResponseBody(name='body'),
}

async function getCorpFinanceWithOptions(request: GetCorpFinanceRequest, runtime: Util.RuntimeOptions): GetCorpFinanceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCorpFinance',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCorpFinance(request: GetCorpFinanceRequest): GetCorpFinanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCorpFinanceWithOptions(request, runtime);
}

model GetCorpNodeInfoRequest {
  oneCompanyId?: string(name='OneCompanyId'),
}

model GetCorpNodeInfoResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
}

model GetCorpNodeInfoResponse = {
  headers: map[string]string(name='headers'),
  body: GetCorpNodeInfoResponseBody(name='body'),
}

async function getCorpNodeInfoWithOptions(request: GetCorpNodeInfoRequest, runtime: Util.RuntimeOptions): GetCorpNodeInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.oneCompanyId)) {
    query['OneCompanyId'] = request.oneCompanyId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCorpNodeInfo',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCorpNodeInfo(request: GetCorpNodeInfoRequest): GetCorpNodeInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCorpNodeInfoWithOptions(request, runtime);
}

model GetCorpProductRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCorpProductResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCorpProductResponse = {
  headers: map[string]string(name='headers'),
  body: GetCorpProductResponseBody(name='body'),
}

async function getCorpProductWithOptions(request: GetCorpProductRequest, runtime: Util.RuntimeOptions): GetCorpProductResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCorpProduct',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCorpProduct(request: GetCorpProductRequest): GetCorpProductResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCorpProductWithOptions(request, runtime);
}

model GetCorpThreeKeysVerificationRequest {
  companyName?: string(name='CompanyName', description='企业名称'),
  legalPersonName?: string(name='LegalPersonName', description='法人'),
  registerNo?: string(name='RegisterNo', description='工商注册号'),
}

model GetCorpThreeKeysVerificationResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
}

model GetCorpThreeKeysVerificationResponse = {
  headers: map[string]string(name='headers'),
  body: GetCorpThreeKeysVerificationResponseBody(name='body'),
}

async function getCorpThreeKeysVerificationWithOptions(request: GetCorpThreeKeysVerificationRequest, runtime: Util.RuntimeOptions): GetCorpThreeKeysVerificationResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.companyName)) {
    query['CompanyName'] = request.companyName;
  }
  if (!Util.isUnset(request.legalPersonName)) {
    query['LegalPersonName'] = request.legalPersonName;
  }
  if (!Util.isUnset(request.registerNo)) {
    query['RegisterNo'] = request.registerNo;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCorpThreeKeysVerification',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCorpThreeKeysVerification(request: GetCorpThreeKeysVerificationRequest): GetCorpThreeKeysVerificationResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCorpThreeKeysVerificationWithOptions(request, runtime);
}

model GetCustCreditImportExportRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCustCreditImportExportResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCustCreditImportExportResponse = {
  headers: map[string]string(name='headers'),
  body: GetCustCreditImportExportResponseBody(name='body'),
}

async function getCustCreditImportExportWithOptions(request: GetCustCreditImportExportRequest, runtime: Util.RuntimeOptions): GetCustCreditImportExportResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCustCreditImportExport',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCustCreditImportExport(request: GetCustCreditImportExportRequest): GetCustCreditImportExportResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCustCreditImportExportWithOptions(request, runtime);
}

model GetCustomPunishThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCustomPunishThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCustomPunishThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetCustomPunishThreeResponseBody(name='body'),
}

async function getCustomPunishThreeWithOptions(request: GetCustomPunishThreeRequest, runtime: Util.RuntimeOptions): GetCustomPunishThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCustomPunishThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCustomPunishThree(request: GetCustomPunishThreeRequest): GetCustomPunishThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCustomPunishThreeWithOptions(request, runtime);
}

model GetCustomsCreditRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetCustomsCreditResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetCustomsCreditResponse = {
  headers: map[string]string(name='headers'),
  body: GetCustomsCreditResponseBody(name='body'),
}

async function getCustomsCreditWithOptions(request: GetCustomsCreditRequest, runtime: Util.RuntimeOptions): GetCustomsCreditResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCustomsCredit',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCustomsCredit(request: GetCustomsCreditRequest): GetCustomsCreditResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCustomsCreditWithOptions(request, runtime);
}

model GetDomianRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetDomianResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetDomianResponse = {
  headers: map[string]string(name='headers'),
  body: GetDomianResponseBody(name='body'),
}

async function getDomianWithOptions(request: GetDomianRequest, runtime: Util.RuntimeOptions): GetDomianResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetDomian',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getDomian(request: GetDomianRequest): GetDomianResponse {
  var runtime = new Util.RuntimeOptions{};
  return getDomianWithOptions(request, runtime);
}

model GetDoubleCheckupRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetDoubleCheckupResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetDoubleCheckupResponse = {
  headers: map[string]string(name='headers'),
  body: GetDoubleCheckupResponseBody(name='body'),
}

async function getDoubleCheckupWithOptions(request: GetDoubleCheckupRequest, runtime: Util.RuntimeOptions): GetDoubleCheckupResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetDoubleCheckup',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getDoubleCheckup(request: GetDoubleCheckupRequest): GetDoubleCheckupResponse {
  var runtime = new Util.RuntimeOptions{};
  return getDoubleCheckupWithOptions(request, runtime);
}

model GetFoodDrugAdministrationThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetFoodDrugAdministrationThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetFoodDrugAdministrationThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetFoodDrugAdministrationThreeResponseBody(name='body'),
}

async function getFoodDrugAdministrationThreeWithOptions(request: GetFoodDrugAdministrationThreeRequest, runtime: Util.RuntimeOptions): GetFoodDrugAdministrationThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetFoodDrugAdministrationThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getFoodDrugAdministrationThree(request: GetFoodDrugAdministrationThreeRequest): GetFoodDrugAdministrationThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getFoodDrugAdministrationThreeWithOptions(request, runtime);
}

model GetGeneralTaxpayerRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetGeneralTaxpayerResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetGeneralTaxpayerResponse = {
  headers: map[string]string(name='headers'),
  body: GetGeneralTaxpayerResponseBody(name='body'),
}

async function getGeneralTaxpayerWithOptions(request: GetGeneralTaxpayerRequest, runtime: Util.RuntimeOptions): GetGeneralTaxpayerResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetGeneralTaxpayer',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getGeneralTaxpayer(request: GetGeneralTaxpayerRequest): GetGeneralTaxpayerResponse {
  var runtime = new Util.RuntimeOptions{};
  return getGeneralTaxpayerWithOptions(request, runtime);
}

model GetJudicialFreezesRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetJudicialFreezesResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetJudicialFreezesResponse = {
  headers: map[string]string(name='headers'),
  body: GetJudicialFreezesResponseBody(name='body'),
}

async function getJudicialFreezesWithOptions(request: GetJudicialFreezesRequest, runtime: Util.RuntimeOptions): GetJudicialFreezesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetJudicialFreezes',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getJudicialFreezes(request: GetJudicialFreezesRequest): GetJudicialFreezesResponse {
  var runtime = new Util.RuntimeOptions{};
  return getJudicialFreezesWithOptions(request, runtime);
}

model GetJudicialReviewFreezingThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetJudicialReviewFreezingThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetJudicialReviewFreezingThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetJudicialReviewFreezingThreeResponseBody(name='body'),
}

async function getJudicialReviewFreezingThreeWithOptions(request: GetJudicialReviewFreezingThreeRequest, runtime: Util.RuntimeOptions): GetJudicialReviewFreezingThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetJudicialReviewFreezingThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getJudicialReviewFreezingThree(request: GetJudicialReviewFreezingThreeRequest): GetJudicialReviewFreezingThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getJudicialReviewFreezingThreeWithOptions(request, runtime);
}

model GetKnowledgePropertiesPledgeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetKnowledgePropertiesPledgeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetKnowledgePropertiesPledgeResponse = {
  headers: map[string]string(name='headers'),
  body: GetKnowledgePropertiesPledgeResponseBody(name='body'),
}

async function getKnowledgePropertiesPledgeWithOptions(request: GetKnowledgePropertiesPledgeRequest, runtime: Util.RuntimeOptions): GetKnowledgePropertiesPledgeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetKnowledgePropertiesPledge',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getKnowledgePropertiesPledge(request: GetKnowledgePropertiesPledgeRequest): GetKnowledgePropertiesPledgeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getKnowledgePropertiesPledgeWithOptions(request, runtime);
}

model GetLcenseInfomationRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetLcenseInfomationResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetLcenseInfomationResponse = {
  headers: map[string]string(name='headers'),
  body: GetLcenseInfomationResponseBody(name='body'),
}

async function getLcenseInfomationWithOptions(request: GetLcenseInfomationRequest, runtime: Util.RuntimeOptions): GetLcenseInfomationResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetLcenseInfomation',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getLcenseInfomation(request: GetLcenseInfomationRequest): GetLcenseInfomationResponse {
  var runtime = new Util.RuntimeOptions{};
  return getLcenseInfomationWithOptions(request, runtime);
}

model GetLegalAuctionRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetLegalAuctionResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetLegalAuctionResponse = {
  headers: map[string]string(name='headers'),
  body: GetLegalAuctionResponseBody(name='body'),
}

async function getLegalAuctionWithOptions(request: GetLegalAuctionRequest, runtime: Util.RuntimeOptions): GetLegalAuctionResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetLegalAuction',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getLegalAuction(request: GetLegalAuctionRequest): GetLegalAuctionResponse {
  var runtime = new Util.RuntimeOptions{};
  return getLegalAuctionWithOptions(request, runtime);
}

model GetLegalNoticesThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetLegalNoticesThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetLegalNoticesThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetLegalNoticesThreeResponseBody(name='body'),
}

async function getLegalNoticesThreeWithOptions(request: GetLegalNoticesThreeRequest, runtime: Util.RuntimeOptions): GetLegalNoticesThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetLegalNoticesThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getLegalNoticesThree(request: GetLegalNoticesThreeRequest): GetLegalNoticesThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getLegalNoticesThreeWithOptions(request, runtime);
}

model GetNearbyCompanyRequest {
  corpKey?: string(name='CorpKey'),
  distance?: float(name='Distance'),
  lat?: float(name='Lat'),
  limit?: int32(name='Limit'),
  lon?: float(name='Lon'),
  offset?: int32(name='Offset'),
}

model GetNearbyCompanyResponseBody = {
  code?: int32(name='Code'),
  data?: [ 
    {
      bizStatus?: string(name='BizStatus'),
      corpName?: string(name='CorpName'),
      distance?: float(name='Distance'),
      industry?: string(name='Industry'),
      oneCompId?: string(name='OneCompId'),
      regAddress?: string(name='RegAddress'),
      regCap?: float(name='RegCap'),
      regLat?: float(name='RegLat'),
      regLon?: float(name='RegLon'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetNearbyCompanyResponse = {
  headers: map[string]string(name='headers'),
  body: GetNearbyCompanyResponseBody(name='body'),
}

async function getNearbyCompanyWithOptions(request: GetNearbyCompanyRequest, runtime: Util.RuntimeOptions): GetNearbyCompanyResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.corpKey)) {
    query['CorpKey'] = request.corpKey;
  }
  if (!Util.isUnset(request.distance)) {
    query['Distance'] = request.distance;
  }
  if (!Util.isUnset(request.lat)) {
    query['Lat'] = request.lat;
  }
  if (!Util.isUnset(request.limit)) {
    query['Limit'] = request.limit;
  }
  if (!Util.isUnset(request.lon)) {
    query['Lon'] = request.lon;
  }
  if (!Util.isUnset(request.offset)) {
    query['Offset'] = request.offset;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetNearbyCompany',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getNearbyCompany(request: GetNearbyCompanyRequest): GetNearbyCompanyResponse {
  var runtime = new Util.RuntimeOptions{};
  return getNearbyCompanyWithOptions(request, runtime);
}

model GetOperateAbnormalRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetOperateAbnormalResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetOperateAbnormalResponse = {
  headers: map[string]string(name='headers'),
  body: GetOperateAbnormalResponseBody(name='body'),
}

async function getOperateAbnormalWithOptions(request: GetOperateAbnormalRequest, runtime: Util.RuntimeOptions): GetOperateAbnormalResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetOperateAbnormal',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOperateAbnormal(request: GetOperateAbnormalRequest): GetOperateAbnormalResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOperateAbnormalWithOptions(request, runtime);
}

model GetOverdueTaxsThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetOverdueTaxsThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetOverdueTaxsThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetOverdueTaxsThreeResponseBody(name='body'),
}

async function getOverdueTaxsThreeWithOptions(request: GetOverdueTaxsThreeRequest, runtime: Util.RuntimeOptions): GetOverdueTaxsThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetOverdueTaxsThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOverdueTaxsThree(request: GetOverdueTaxsThreeRequest): GetOverdueTaxsThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOverdueTaxsThreeWithOptions(request, runtime);
}

model GetPurchaseLandInformationRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetPurchaseLandInformationResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetPurchaseLandInformationResponse = {
  headers: map[string]string(name='headers'),
  body: GetPurchaseLandInformationResponseBody(name='body'),
}

async function getPurchaseLandInformationWithOptions(request: GetPurchaseLandInformationRequest, runtime: Util.RuntimeOptions): GetPurchaseLandInformationResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetPurchaseLandInformation',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getPurchaseLandInformation(request: GetPurchaseLandInformationRequest): GetPurchaseLandInformationResponse {
  var runtime = new Util.RuntimeOptions{};
  return getPurchaseLandInformationWithOptions(request, runtime);
}

model GetQualificationCertificateRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetQualificationCertificateResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetQualificationCertificateResponse = {
  headers: map[string]string(name='headers'),
  body: GetQualificationCertificateResponseBody(name='body'),
}

async function getQualificationCertificateWithOptions(request: GetQualificationCertificateRequest, runtime: Util.RuntimeOptions): GetQualificationCertificateResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetQualificationCertificate',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getQualificationCertificate(request: GetQualificationCertificateRequest): GetQualificationCertificateResponse {
  var runtime = new Util.RuntimeOptions{};
  return getQualificationCertificateWithOptions(request, runtime);
}

model GetQualityPunishmentThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetQualityPunishmentThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetQualityPunishmentThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetQualityPunishmentThreeResponseBody(name='body'),
}

async function getQualityPunishmentThreeWithOptions(request: GetQualityPunishmentThreeRequest, runtime: Util.RuntimeOptions): GetQualityPunishmentThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetQualityPunishmentThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getQualityPunishmentThree(request: GetQualityPunishmentThreeRequest): GetQualityPunishmentThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getQualityPunishmentThreeWithOptions(request, runtime);
}

model GetRecruitInfoRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetRecruitInfoResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetRecruitInfoResponse = {
  headers: map[string]string(name='headers'),
  body: GetRecruitInfoResponseBody(name='body'),
}

async function getRecruitInfoWithOptions(request: GetRecruitInfoRequest, runtime: Util.RuntimeOptions): GetRecruitInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRecruitInfo',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getRecruitInfo(request: GetRecruitInfoRequest): GetRecruitInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRecruitInfoWithOptions(request, runtime);
}

model GetRskMortgageRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetRskMortgageResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetRskMortgageResponse = {
  headers: map[string]string(name='headers'),
  body: GetRskMortgageResponseBody(name='body'),
}

async function getRskMortgageWithOptions(request: GetRskMortgageRequest, runtime: Util.RuntimeOptions): GetRskMortgageResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRskMortgage',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getRskMortgage(request: GetRskMortgageRequest): GetRskMortgageResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRskMortgageWithOptions(request, runtime);
}

model GetSatpartyPunishThreeRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetSatpartyPunishThreeResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetSatpartyPunishThreeResponse = {
  headers: map[string]string(name='headers'),
  body: GetSatpartyPunishThreeResponseBody(name='body'),
}

async function getSatpartyPunishThreeWithOptions(request: GetSatpartyPunishThreeRequest, runtime: Util.RuntimeOptions): GetSatpartyPunishThreeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSatpartyPunishThree',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSatpartyPunishThree(request: GetSatpartyPunishThreeRequest): GetSatpartyPunishThreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSatpartyPunishThreeWithOptions(request, runtime);
}

model GetSearchConditionRequest {
  conditionType?: string(name='ConditionType'),
}

model GetSearchConditionResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
}

model GetSearchConditionResponse = {
  headers: map[string]string(name='headers'),
  body: GetSearchConditionResponseBody(name='body'),
}

async function getSearchConditionWithOptions(request: GetSearchConditionRequest, runtime: Util.RuntimeOptions): GetSearchConditionResponse {
  Util.validateModel(request);
  var body : map[string]any= {};
  if (!Util.isUnset(request.conditionType)) {
    body['ConditionType'] = request.conditionType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetSearchCondition',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSearchCondition(request: GetSearchConditionRequest): GetSearchConditionResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSearchConditionWithOptions(request, runtime);
}

model GetSeriousIllegalRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetSeriousIllegalResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetSeriousIllegalResponse = {
  headers: map[string]string(name='headers'),
  body: GetSeriousIllegalResponseBody(name='body'),
}

async function getSeriousIllegalWithOptions(request: GetSeriousIllegalRequest, runtime: Util.RuntimeOptions): GetSeriousIllegalResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSeriousIllegal',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSeriousIllegal(request: GetSeriousIllegalRequest): GetSeriousIllegalResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSeriousIllegalWithOptions(request, runtime);
}

model GetSimpleCancelRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetSimpleCancelResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetSimpleCancelResponse = {
  headers: map[string]string(name='headers'),
  body: GetSimpleCancelResponseBody(name='body'),
}

async function getSimpleCancelWithOptions(request: GetSimpleCancelRequest, runtime: Util.RuntimeOptions): GetSimpleCancelResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSimpleCancel',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSimpleCancel(request: GetSimpleCancelRequest): GetSimpleCancelResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSimpleCancelWithOptions(request, runtime);
}

model GetSoftCopyrightRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetSoftCopyrightResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetSoftCopyrightResponse = {
  headers: map[string]string(name='headers'),
  body: GetSoftCopyrightResponseBody(name='body'),
}

async function getSoftCopyrightWithOptions(request: GetSoftCopyrightRequest, runtime: Util.RuntimeOptions): GetSoftCopyrightResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSoftCopyright',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSoftCopyright(request: GetSoftCopyrightRequest): GetSoftCopyrightResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSoftCopyrightWithOptions(request, runtime);
}

model GetStockListRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetStockListResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetStockListResponse = {
  headers: map[string]string(name='headers'),
  body: GetStockListResponseBody(name='body'),
}

async function getStockListWithOptions(request: GetStockListRequest, runtime: Util.RuntimeOptions): GetStockListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetStockList',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getStockList(request: GetStockListRequest): GetStockListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getStockListWithOptions(request, runtime);
}

model GetTaxLevelRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetTaxLevelResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetTaxLevelResponse = {
  headers: map[string]string(name='headers'),
  body: GetTaxLevelResponseBody(name='body'),
}

async function getTaxLevelWithOptions(request: GetTaxLevelRequest, runtime: Util.RuntimeOptions): GetTaxLevelResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetTaxLevel',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTaxLevel(request: GetTaxLevelRequest): GetTaxLevelResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTaxLevelWithOptions(request, runtime);
}

model GetTerminationCaseRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetTerminationCaseResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetTerminationCaseResponse = {
  headers: map[string]string(name='headers'),
  body: GetTerminationCaseResponseBody(name='body'),
}

async function getTerminationCaseWithOptions(request: GetTerminationCaseRequest, runtime: Util.RuntimeOptions): GetTerminationCaseResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetTerminationCase',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTerminationCase(request: GetTerminationCaseRequest): GetTerminationCaseResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTerminationCaseWithOptions(request, runtime);
}

model GetTrademarkRequest {
  fetchFieldList?: string(name='FetchFieldList'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  searchKey?: string(name='SearchKey'),
}

model GetTrademarkResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetTrademarkResponse = {
  headers: map[string]string(name='headers'),
  body: GetTrademarkResponseBody(name='body'),
}

async function getTrademarkWithOptions(request: GetTrademarkRequest, runtime: Util.RuntimeOptions): GetTrademarkResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fetchFieldList)) {
    query['FetchFieldList'] = request.fetchFieldList;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKey)) {
    query['SearchKey'] = request.searchKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetTrademark',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTrademark(request: GetTrademarkRequest): GetTrademarkResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTrademarkWithOptions(request, runtime);
}

model GetTwoCorpsRelationshipRequest {
  endCropName?: string(name='EndCropName'),
  fromCorpName?: string(name='FromCorpName'),
  maxPath?: int32(name='MaxPath'),
}

model GetTwoCorpsRelationshipResponseBody = {
  code?: int32(name='Code'),
  data?: [ 
    {
      nodes?: [ 
        {
          id?: string(name='Id'),
          label?: string(name='Label'),
          name?: string(name='Name'),
        }
      ](name='Nodes'),
      relationLevel?: int32(name='RelationLevel'),
      relationRank?: int32(name='RelationRank'),
      relationships?: [ 
        {
          endNode?: string(name='EndNode'),
          id?: string(name='Id'),
          properties?: map[string]any(name='Properties'),
          startNode?: string(name='StartNode'),
          type?: string(name='Type'),
        }
      ](name='Relationships'),
      strength?: float(name='Strength'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model GetTwoCorpsRelationshipResponse = {
  headers: map[string]string(name='headers'),
  body: GetTwoCorpsRelationshipResponseBody(name='body'),
}

async function getTwoCorpsRelationshipWithOptions(request: GetTwoCorpsRelationshipRequest, runtime: Util.RuntimeOptions): GetTwoCorpsRelationshipResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.endCropName)) {
    query['EndCropName'] = request.endCropName;
  }
  if (!Util.isUnset(request.fromCorpName)) {
    query['FromCorpName'] = request.fromCorpName;
  }
  if (!Util.isUnset(request.maxPath)) {
    query['MaxPath'] = request.maxPath;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetTwoCorpsRelationship',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTwoCorpsRelationship(request: GetTwoCorpsRelationshipRequest): GetTwoCorpsRelationshipResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTwoCorpsRelationshipWithOptions(request, runtime);
}

model ListCompaniesRequest {
  bizCategories?: map[string]any(name='BizCategories'),
  bizInfo?: map[string]any(name='BizInfo'),
  bizScopeKeyword?: map[string]any(name='BizScopeKeyword'),
  bizStatus?: map[string]any(name='BizStatus'),
  bizType?: map[string]any(name='BizType'),
  brandInfo?: map[string]any(name='BrandInfo'),
  buildTime?: map[string]any(name='BuildTime'),
  companyType?: map[string]any(name='CompanyType'),
  corpName?: string(name='CorpName'),
  licenseNumber?: string(name='LicenseNumber'),
  lifecycle?: map[string]any(name='Lifecycle'),
  limit?: int32(name='Limit'),
  newCorp?: string(name='NewCorp'),
  offset?: int32(name='Offset'),
  orderBy?: map[string]any(name='OrderBy'),
  orgNo?: string(name='OrgNo'),
  productShopMatch?: string(name='ProductShopMatch'),
  recCap?: string(name='RecCap'),
  regions?: map[string]any(name='Regions'),
  registerAssert?: map[string]any(name='RegisterAssert'),
  spreadInfo?: map[string]any(name='SpreadInfo'),
  staffSize?: map[string]any(name='StaffSize'),
}

model ListCompaniesShrinkRequest {
  bizCategoriesShrink?: string(name='BizCategories'),
  bizInfoShrink?: string(name='BizInfo'),
  bizScopeKeywordShrink?: string(name='BizScopeKeyword'),
  bizStatusShrink?: string(name='BizStatus'),
  bizTypeShrink?: string(name='BizType'),
  brandInfoShrink?: string(name='BrandInfo'),
  buildTimeShrink?: string(name='BuildTime'),
  companyTypeShrink?: string(name='CompanyType'),
  corpName?: string(name='CorpName'),
  licenseNumber?: string(name='LicenseNumber'),
  lifecycleShrink?: string(name='Lifecycle'),
  limit?: int32(name='Limit'),
  newCorp?: string(name='NewCorp'),
  offset?: int32(name='Offset'),
  orderByShrink?: string(name='OrderBy'),
  orgNo?: string(name='OrgNo'),
  productShopMatch?: string(name='ProductShopMatch'),
  recCap?: string(name='RecCap'),
  regionsShrink?: string(name='Regions'),
  registerAssertShrink?: string(name='RegisterAssert'),
  spreadInfoShrink?: string(name='SpreadInfo'),
  staffSizeShrink?: string(name='StaffSize'),
}

model ListCompaniesResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model ListCompaniesResponse = {
  headers: map[string]string(name='headers'),
  body: ListCompaniesResponseBody(name='body'),
}

async function listCompaniesWithOptions(tmpReq: ListCompaniesRequest, runtime: Util.RuntimeOptions): ListCompaniesResponse {
  Util.validateModel(tmpReq);
  var request = new ListCompaniesShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.bizCategories)) {
    request.bizCategoriesShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.bizCategories, 'BizCategories', 'json');
  }
  if (!Util.isUnset(tmpReq.bizInfo)) {
    request.bizInfoShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.bizInfo, 'BizInfo', 'json');
  }
  if (!Util.isUnset(tmpReq.bizScopeKeyword)) {
    request.bizScopeKeywordShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.bizScopeKeyword, 'BizScopeKeyword', 'json');
  }
  if (!Util.isUnset(tmpReq.bizStatus)) {
    request.bizStatusShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.bizStatus, 'BizStatus', 'json');
  }
  if (!Util.isUnset(tmpReq.bizType)) {
    request.bizTypeShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.bizType, 'BizType', 'json');
  }
  if (!Util.isUnset(tmpReq.brandInfo)) {
    request.brandInfoShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.brandInfo, 'BrandInfo', 'json');
  }
  if (!Util.isUnset(tmpReq.buildTime)) {
    request.buildTimeShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.buildTime, 'BuildTime', 'json');
  }
  if (!Util.isUnset(tmpReq.companyType)) {
    request.companyTypeShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.companyType, 'CompanyType', 'json');
  }
  if (!Util.isUnset(tmpReq.lifecycle)) {
    request.lifecycleShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.lifecycle, 'Lifecycle', 'json');
  }
  if (!Util.isUnset(tmpReq.orderBy)) {
    request.orderByShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.orderBy, 'OrderBy', 'json');
  }
  if (!Util.isUnset(tmpReq.regions)) {
    request.regionsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.regions, 'Regions', 'json');
  }
  if (!Util.isUnset(tmpReq.registerAssert)) {
    request.registerAssertShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.registerAssert, 'RegisterAssert', 'json');
  }
  if (!Util.isUnset(tmpReq.spreadInfo)) {
    request.spreadInfoShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.spreadInfo, 'SpreadInfo', 'json');
  }
  if (!Util.isUnset(tmpReq.staffSize)) {
    request.staffSizeShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.staffSize, 'StaffSize', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.corpName)) {
    query['CorpName'] = request.corpName;
  }
  if (!Util.isUnset(request.licenseNumber)) {
    query['LicenseNumber'] = request.licenseNumber;
  }
  if (!Util.isUnset(request.limit)) {
    query['Limit'] = request.limit;
  }
  if (!Util.isUnset(request.offset)) {
    query['Offset'] = request.offset;
  }
  if (!Util.isUnset(request.orgNo)) {
    query['OrgNo'] = request.orgNo;
  }
  if (!Util.isUnset(request.productShopMatch)) {
    query['ProductShopMatch'] = request.productShopMatch;
  }
  if (!Util.isUnset(request.recCap)) {
    query['RecCap'] = request.recCap;
  }
  var body : map[string]any= {};
  if (!Util.isUnset(request.bizCategoriesShrink)) {
    body['BizCategories'] = request.bizCategoriesShrink;
  }
  if (!Util.isUnset(request.bizInfoShrink)) {
    body['BizInfo'] = request.bizInfoShrink;
  }
  if (!Util.isUnset(request.bizScopeKeywordShrink)) {
    body['BizScopeKeyword'] = request.bizScopeKeywordShrink;
  }
  if (!Util.isUnset(request.bizStatusShrink)) {
    body['BizStatus'] = request.bizStatusShrink;
  }
  if (!Util.isUnset(request.bizTypeShrink)) {
    body['BizType'] = request.bizTypeShrink;
  }
  if (!Util.isUnset(request.brandInfoShrink)) {
    body['BrandInfo'] = request.brandInfoShrink;
  }
  if (!Util.isUnset(request.buildTimeShrink)) {
    body['BuildTime'] = request.buildTimeShrink;
  }
  if (!Util.isUnset(request.companyTypeShrink)) {
    body['CompanyType'] = request.companyTypeShrink;
  }
  if (!Util.isUnset(request.lifecycleShrink)) {
    body['Lifecycle'] = request.lifecycleShrink;
  }
  if (!Util.isUnset(request.newCorp)) {
    body['NewCorp'] = request.newCorp;
  }
  if (!Util.isUnset(request.orderByShrink)) {
    body['OrderBy'] = request.orderByShrink;
  }
  if (!Util.isUnset(request.regionsShrink)) {
    body['Regions'] = request.regionsShrink;
  }
  if (!Util.isUnset(request.registerAssertShrink)) {
    body['RegisterAssert'] = request.registerAssertShrink;
  }
  if (!Util.isUnset(request.spreadInfoShrink)) {
    body['SpreadInfo'] = request.spreadInfoShrink;
  }
  if (!Util.isUnset(request.staffSizeShrink)) {
    body['StaffSize'] = request.staffSizeShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListCompanies',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listCompanies(request: ListCompaniesRequest): ListCompaniesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCompaniesWithOptions(request, runtime);
}

model QueryCompanyRequest {
  bizCategory?: map[string]any(name='BizCategory'),
  bizScope?: map[string]any(name='BizScope'),
  bizScopeKeyword?: string(name='BizScopeKeyword'),
  bizStatus?: map[string]any(name='BizStatus'),
  bizType?: map[string]any(name='BizType'),
  brandInfo?: map[string]any(name='BrandInfo'),
  buildTime?: map[string]any(name='BuildTime'),
  companyName?: string(name='CompanyName'),
  companyNames?: map[string]any(name='CompanyNames'),
  companyType?: map[string]any(name='CompanyType'),
  corpHouseId?: int32(name='CorpHouseId'),
  corpHouseName?: string(name='CorpHouseName'),
  dataModuleIds?: map[string]any(name='DataModuleIds'),
  electronicBusinessYear?: string(name='ElectronicBusinessYear'),
  electronicBusinessYearType?: string(name='ElectronicBusinessYearType'),
  esDateEnd?: string(name='EsDateEnd'),
  esDateStart?: string(name='EsDateStart'),
  fetchFieldList?: map[string]any(name='FetchFieldList'),
  fetchLbsInfo?: boolean(name='FetchLbsInfo'),
  filterUnusedCompany?: boolean(name='FilterUnusedCompany'),
  hasFinance?: string(name='HasFinance'),
  isAboveScale?: string(name='IsAboveScale'),
  isAgency?: string(name='IsAgency'),
  isBidding?: string(name='IsBidding'),
  isBranch?: string(name='IsBranch'),
  isDeadNum?: string(name='IsDeadNum'),
  isElectronicBusiness?: string(name='IsElectronicBusiness'),
  isEmail?: string(name='IsEmail'),
  isFixedPhone?: string(name='IsFixedPhone'),
  isHasEShop?: string(name='IsHasEShop'),
  isHomeUrl?: string(name='IsHomeUrl'),
  isImportOutput?: string(name='IsImportOutput'),
  isIndividual?: string(name='IsIndividual'),
  isInvestment?: string(name='IsInvestment'),
  isIpDomains?: string(name='IsIpDomains'),
  isLegalComp?: string(name='IsLegalComp'),
  isMobilePhone?: string(name='IsMobilePhone'),
  isNormalCopyrights?: string(name='IsNormalCopyrights'),
  isPatents?: string(name='IsPatents'),
  isProductNames?: string(name='IsProductNames'),
  isPublic?: string(name='IsPublic'),
  isRecruit?: string(name='IsRecruit'),
  isRiskLegalExecutions?: string(name='IsRiskLegalExecutions'),
  isSoftCopyrights?: string(name='IsSoftCopyrights'),
  isTierATaxpayer?: string(name='IsTierATaxpayer'),
  isTrademarks?: string(name='IsTrademarks'),
  isValidPhone?: string(name='IsValidPhone'),
  isZone?: string(name='IsZone'),
  jobTimeLevel?: string(name='JobTimeLevel'),
  keyword?: string(name='Keyword'),
  lbsParam?: map[string]any(name='LbsParam'),
  lifecycle?: map[string]any(name='Lifecycle'),
  listedStatus?: map[string]any(name='ListedStatus'),
  oneCompanyId?: string(name='OneCompanyId'),
  orderByType?: int32(name='OrderByType'),
  ossKey?: string(name='OssKey'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  positionName?: string(name='PositionName'),
  positionRequirement?: string(name='PositionRequirement'),
  positionWelfare?: string(name='PositionWelfare'),
  powerTag?: map[string]any(name='PowerTag'),
  productShopMatch?: string(name='ProductShopMatch'),
  pushDataLimit?: long(name='PushDataLimit'),
  pushUrl?: string(name='PushUrl'),
  recruitEducationLevel?: string(name='RecruitEducationLevel'),
  recruitPayLevel?: string(name='RecruitPayLevel'),
  recruitProvince?: string(name='RecruitProvince'),
  regions?: map[string]any(name='Regions'),
  registerCapital?: map[string]any(name='RegisterCapital'),
  registerCapitalEnd?: int32(name='RegisterCapitalEnd'),
  registerCapitalStart?: int32(name='RegisterCapitalStart'),
  registerCapitalType?: map[string]any(name='RegisterCapitalType'),
  searchNewComp?: boolean(name='SearchNewComp'),
  spreadInfo?: map[string]any(name='SpreadInfo'),
  staffSize?: map[string]any(name='StaffSize'),
  taskId?: string(name='TaskId'),
  transformRate?: map[string]any(name='TransformRate'),
}

model QueryCompanyShrinkRequest {
  bizCategoryShrink?: string(name='BizCategory'),
  bizScopeShrink?: string(name='BizScope'),
  bizScopeKeyword?: string(name='BizScopeKeyword'),
  bizStatusShrink?: string(name='BizStatus'),
  bizTypeShrink?: string(name='BizType'),
  brandInfoShrink?: string(name='BrandInfo'),
  buildTimeShrink?: string(name='BuildTime'),
  companyName?: string(name='CompanyName'),
  companyNamesShrink?: string(name='CompanyNames'),
  companyTypeShrink?: string(name='CompanyType'),
  corpHouseId?: int32(name='CorpHouseId'),
  corpHouseName?: string(name='CorpHouseName'),
  dataModuleIdsShrink?: string(name='DataModuleIds'),
  electronicBusinessYear?: string(name='ElectronicBusinessYear'),
  electronicBusinessYearType?: string(name='ElectronicBusinessYearType'),
  esDateEnd?: string(name='EsDateEnd'),
  esDateStart?: string(name='EsDateStart'),
  fetchFieldListShrink?: string(name='FetchFieldList'),
  fetchLbsInfo?: boolean(name='FetchLbsInfo'),
  filterUnusedCompany?: boolean(name='FilterUnusedCompany'),
  hasFinance?: string(name='HasFinance'),
  isAboveScale?: string(name='IsAboveScale'),
  isAgency?: string(name='IsAgency'),
  isBidding?: string(name='IsBidding'),
  isBranch?: string(name='IsBranch'),
  isDeadNum?: string(name='IsDeadNum'),
  isElectronicBusiness?: string(name='IsElectronicBusiness'),
  isEmail?: string(name='IsEmail'),
  isFixedPhone?: string(name='IsFixedPhone'),
  isHasEShop?: string(name='IsHasEShop'),
  isHomeUrl?: string(name='IsHomeUrl'),
  isImportOutput?: string(name='IsImportOutput'),
  isIndividual?: string(name='IsIndividual'),
  isInvestment?: string(name='IsInvestment'),
  isIpDomains?: string(name='IsIpDomains'),
  isLegalComp?: string(name='IsLegalComp'),
  isMobilePhone?: string(name='IsMobilePhone'),
  isNormalCopyrights?: string(name='IsNormalCopyrights'),
  isPatents?: string(name='IsPatents'),
  isProductNames?: string(name='IsProductNames'),
  isPublic?: string(name='IsPublic'),
  isRecruit?: string(name='IsRecruit'),
  isRiskLegalExecutions?: string(name='IsRiskLegalExecutions'),
  isSoftCopyrights?: string(name='IsSoftCopyrights'),
  isTierATaxpayer?: string(name='IsTierATaxpayer'),
  isTrademarks?: string(name='IsTrademarks'),
  isValidPhone?: string(name='IsValidPhone'),
  isZone?: string(name='IsZone'),
  jobTimeLevel?: string(name='JobTimeLevel'),
  keyword?: string(name='Keyword'),
  lbsParamShrink?: string(name='LbsParam'),
  lifecycleShrink?: string(name='Lifecycle'),
  listedStatusShrink?: string(name='ListedStatus'),
  oneCompanyId?: string(name='OneCompanyId'),
  orderByType?: int32(name='OrderByType'),
  ossKey?: string(name='OssKey'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  positionName?: string(name='PositionName'),
  positionRequirement?: string(name='PositionRequirement'),
  positionWelfare?: string(name='PositionWelfare'),
  powerTagShrink?: string(name='PowerTag'),
  productShopMatch?: string(name='ProductShopMatch'),
  pushDataLimit?: long(name='PushDataLimit'),
  pushUrl?: string(name='PushUrl'),
  recruitEducationLevel?: string(name='RecruitEducationLevel'),
  recruitPayLevel?: string(name='RecruitPayLevel'),
  recruitProvince?: string(name='RecruitProvince'),
  regionsShrink?: string(name='Regions'),
  registerCapitalShrink?: string(name='RegisterCapital'),
  registerCapitalEnd?: int32(name='RegisterCapitalEnd'),
  registerCapitalStart?: int32(name='RegisterCapitalStart'),
  registerCapitalTypeShrink?: string(name='RegisterCapitalType'),
  searchNewComp?: boolean(name='SearchNewComp'),
  spreadInfoShrink?: string(name='SpreadInfo'),
  staffSizeShrink?: string(name='StaffSize'),
  taskId?: string(name='TaskId'),
  transformRateShrink?: string(name='TransformRate'),
}

model QueryCompanyResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model QueryCompanyResponse = {
  headers: map[string]string(name='headers'),
  body: QueryCompanyResponseBody(name='body'),
}

async function queryCompanyWithOptions(tmpReq: QueryCompanyRequest, runtime: Util.RuntimeOptions): QueryCompanyResponse {
  Util.validateModel(tmpReq);
  var request = new QueryCompanyShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.bizCategory)) {
    request.bizCategoryShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.bizCategory, 'BizCategory', 'json');
  }
  if (!Util.isUnset(tmpReq.bizScope)) {
    request.bizScopeShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.bizScope, 'BizScope', 'json');
  }
  if (!Util.isUnset(tmpReq.bizStatus)) {
    request.bizStatusShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.bizStatus, 'BizStatus', 'json');
  }
  if (!Util.isUnset(tmpReq.bizType)) {
    request.bizTypeShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.bizType, 'BizType', 'json');
  }
  if (!Util.isUnset(tmpReq.brandInfo)) {
    request.brandInfoShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.brandInfo, 'BrandInfo', 'json');
  }
  if (!Util.isUnset(tmpReq.buildTime)) {
    request.buildTimeShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.buildTime, 'BuildTime', 'json');
  }
  if (!Util.isUnset(tmpReq.companyNames)) {
    request.companyNamesShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.companyNames, 'CompanyNames', 'json');
  }
  if (!Util.isUnset(tmpReq.companyType)) {
    request.companyTypeShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.companyType, 'CompanyType', 'json');
  }
  if (!Util.isUnset(tmpReq.dataModuleIds)) {
    request.dataModuleIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.dataModuleIds, 'DataModuleIds', 'json');
  }
  if (!Util.isUnset(tmpReq.fetchFieldList)) {
    request.fetchFieldListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.fetchFieldList, 'FetchFieldList', 'json');
  }
  if (!Util.isUnset(tmpReq.lbsParam)) {
    request.lbsParamShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.lbsParam, 'LbsParam', 'json');
  }
  if (!Util.isUnset(tmpReq.lifecycle)) {
    request.lifecycleShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.lifecycle, 'Lifecycle', 'json');
  }
  if (!Util.isUnset(tmpReq.listedStatus)) {
    request.listedStatusShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.listedStatus, 'ListedStatus', 'json');
  }
  if (!Util.isUnset(tmpReq.powerTag)) {
    request.powerTagShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.powerTag, 'PowerTag', 'json');
  }
  if (!Util.isUnset(tmpReq.regions)) {
    request.regionsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.regions, 'Regions', 'json');
  }
  if (!Util.isUnset(tmpReq.registerCapital)) {
    request.registerCapitalShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.registerCapital, 'RegisterCapital', 'json');
  }
  if (!Util.isUnset(tmpReq.registerCapitalType)) {
    request.registerCapitalTypeShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.registerCapitalType, 'RegisterCapitalType', 'json');
  }
  if (!Util.isUnset(tmpReq.spreadInfo)) {
    request.spreadInfoShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.spreadInfo, 'SpreadInfo', 'json');
  }
  if (!Util.isUnset(tmpReq.staffSize)) {
    request.staffSizeShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.staffSize, 'StaffSize', 'json');
  }
  if (!Util.isUnset(tmpReq.transformRate)) {
    request.transformRateShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.transformRate, 'TransformRate', 'json');
  }
  var body : map[string]any= {};
  if (!Util.isUnset(request.bizCategoryShrink)) {
    body['BizCategory'] = request.bizCategoryShrink;
  }
  if (!Util.isUnset(request.bizScopeShrink)) {
    body['BizScope'] = request.bizScopeShrink;
  }
  if (!Util.isUnset(request.bizScopeKeyword)) {
    body['BizScopeKeyword'] = request.bizScopeKeyword;
  }
  if (!Util.isUnset(request.bizStatusShrink)) {
    body['BizStatus'] = request.bizStatusShrink;
  }
  if (!Util.isUnset(request.bizTypeShrink)) {
    body['BizType'] = request.bizTypeShrink;
  }
  if (!Util.isUnset(request.brandInfoShrink)) {
    body['BrandInfo'] = request.brandInfoShrink;
  }
  if (!Util.isUnset(request.buildTimeShrink)) {
    body['BuildTime'] = request.buildTimeShrink;
  }
  if (!Util.isUnset(request.companyName)) {
    body['CompanyName'] = request.companyName;
  }
  if (!Util.isUnset(request.companyNamesShrink)) {
    body['CompanyNames'] = request.companyNamesShrink;
  }
  if (!Util.isUnset(request.companyTypeShrink)) {
    body['CompanyType'] = request.companyTypeShrink;
  }
  if (!Util.isUnset(request.corpHouseId)) {
    body['CorpHouseId'] = request.corpHouseId;
  }
  if (!Util.isUnset(request.corpHouseName)) {
    body['CorpHouseName'] = request.corpHouseName;
  }
  if (!Util.isUnset(request.dataModuleIdsShrink)) {
    body['DataModuleIds'] = request.dataModuleIdsShrink;
  }
  if (!Util.isUnset(request.electronicBusinessYear)) {
    body['ElectronicBusinessYear'] = request.electronicBusinessYear;
  }
  if (!Util.isUnset(request.electronicBusinessYearType)) {
    body['ElectronicBusinessYearType'] = request.electronicBusinessYearType;
  }
  if (!Util.isUnset(request.esDateEnd)) {
    body['EsDateEnd'] = request.esDateEnd;
  }
  if (!Util.isUnset(request.esDateStart)) {
    body['EsDateStart'] = request.esDateStart;
  }
  if (!Util.isUnset(request.fetchFieldListShrink)) {
    body['FetchFieldList'] = request.fetchFieldListShrink;
  }
  if (!Util.isUnset(request.fetchLbsInfo)) {
    body['FetchLbsInfo'] = request.fetchLbsInfo;
  }
  if (!Util.isUnset(request.filterUnusedCompany)) {
    body['FilterUnusedCompany'] = request.filterUnusedCompany;
  }
  if (!Util.isUnset(request.hasFinance)) {
    body['HasFinance'] = request.hasFinance;
  }
  if (!Util.isUnset(request.isAboveScale)) {
    body['IsAboveScale'] = request.isAboveScale;
  }
  if (!Util.isUnset(request.isAgency)) {
    body['IsAgency'] = request.isAgency;
  }
  if (!Util.isUnset(request.isBidding)) {
    body['IsBidding'] = request.isBidding;
  }
  if (!Util.isUnset(request.isBranch)) {
    body['IsBranch'] = request.isBranch;
  }
  if (!Util.isUnset(request.isDeadNum)) {
    body['IsDeadNum'] = request.isDeadNum;
  }
  if (!Util.isUnset(request.isElectronicBusiness)) {
    body['IsElectronicBusiness'] = request.isElectronicBusiness;
  }
  if (!Util.isUnset(request.isEmail)) {
    body['IsEmail'] = request.isEmail;
  }
  if (!Util.isUnset(request.isFixedPhone)) {
    body['IsFixedPhone'] = request.isFixedPhone;
  }
  if (!Util.isUnset(request.isHasEShop)) {
    body['IsHasEShop'] = request.isHasEShop;
  }
  if (!Util.isUnset(request.isHomeUrl)) {
    body['IsHomeUrl'] = request.isHomeUrl;
  }
  if (!Util.isUnset(request.isImportOutput)) {
    body['IsImportOutput'] = request.isImportOutput;
  }
  if (!Util.isUnset(request.isIndividual)) {
    body['IsIndividual'] = request.isIndividual;
  }
  if (!Util.isUnset(request.isInvestment)) {
    body['IsInvestment'] = request.isInvestment;
  }
  if (!Util.isUnset(request.isIpDomains)) {
    body['IsIpDomains'] = request.isIpDomains;
  }
  if (!Util.isUnset(request.isLegalComp)) {
    body['IsLegalComp'] = request.isLegalComp;
  }
  if (!Util.isUnset(request.isMobilePhone)) {
    body['IsMobilePhone'] = request.isMobilePhone;
  }
  if (!Util.isUnset(request.isNormalCopyrights)) {
    body['IsNormalCopyrights'] = request.isNormalCopyrights;
  }
  if (!Util.isUnset(request.isPatents)) {
    body['IsPatents'] = request.isPatents;
  }
  if (!Util.isUnset(request.isProductNames)) {
    body['IsProductNames'] = request.isProductNames;
  }
  if (!Util.isUnset(request.isPublic)) {
    body['IsPublic'] = request.isPublic;
  }
  if (!Util.isUnset(request.isRecruit)) {
    body['IsRecruit'] = request.isRecruit;
  }
  if (!Util.isUnset(request.isRiskLegalExecutions)) {
    body['IsRiskLegalExecutions'] = request.isRiskLegalExecutions;
  }
  if (!Util.isUnset(request.isSoftCopyrights)) {
    body['IsSoftCopyrights'] = request.isSoftCopyrights;
  }
  if (!Util.isUnset(request.isTierATaxpayer)) {
    body['IsTierATaxpayer'] = request.isTierATaxpayer;
  }
  if (!Util.isUnset(request.isTrademarks)) {
    body['IsTrademarks'] = request.isTrademarks;
  }
  if (!Util.isUnset(request.isValidPhone)) {
    body['IsValidPhone'] = request.isValidPhone;
  }
  if (!Util.isUnset(request.isZone)) {
    body['IsZone'] = request.isZone;
  }
  if (!Util.isUnset(request.jobTimeLevel)) {
    body['JobTimeLevel'] = request.jobTimeLevel;
  }
  if (!Util.isUnset(request.keyword)) {
    body['Keyword'] = request.keyword;
  }
  if (!Util.isUnset(request.lbsParamShrink)) {
    body['LbsParam'] = request.lbsParamShrink;
  }
  if (!Util.isUnset(request.lifecycleShrink)) {
    body['Lifecycle'] = request.lifecycleShrink;
  }
  if (!Util.isUnset(request.listedStatusShrink)) {
    body['ListedStatus'] = request.listedStatusShrink;
  }
  if (!Util.isUnset(request.oneCompanyId)) {
    body['OneCompanyId'] = request.oneCompanyId;
  }
  if (!Util.isUnset(request.orderByType)) {
    body['OrderByType'] = request.orderByType;
  }
  if (!Util.isUnset(request.ossKey)) {
    body['OssKey'] = request.ossKey;
  }
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.positionName)) {
    body['PositionName'] = request.positionName;
  }
  if (!Util.isUnset(request.positionRequirement)) {
    body['PositionRequirement'] = request.positionRequirement;
  }
  if (!Util.isUnset(request.positionWelfare)) {
    body['PositionWelfare'] = request.positionWelfare;
  }
  if (!Util.isUnset(request.powerTagShrink)) {
    body['PowerTag'] = request.powerTagShrink;
  }
  if (!Util.isUnset(request.productShopMatch)) {
    body['ProductShopMatch'] = request.productShopMatch;
  }
  if (!Util.isUnset(request.pushDataLimit)) {
    body['PushDataLimit'] = request.pushDataLimit;
  }
  if (!Util.isUnset(request.pushUrl)) {
    body['PushUrl'] = request.pushUrl;
  }
  if (!Util.isUnset(request.recruitEducationLevel)) {
    body['RecruitEducationLevel'] = request.recruitEducationLevel;
  }
  if (!Util.isUnset(request.recruitPayLevel)) {
    body['RecruitPayLevel'] = request.recruitPayLevel;
  }
  if (!Util.isUnset(request.recruitProvince)) {
    body['RecruitProvince'] = request.recruitProvince;
  }
  if (!Util.isUnset(request.regionsShrink)) {
    body['Regions'] = request.regionsShrink;
  }
  if (!Util.isUnset(request.registerCapitalShrink)) {
    body['RegisterCapital'] = request.registerCapitalShrink;
  }
  if (!Util.isUnset(request.registerCapitalEnd)) {
    body['RegisterCapitalEnd'] = request.registerCapitalEnd;
  }
  if (!Util.isUnset(request.registerCapitalStart)) {
    body['RegisterCapitalStart'] = request.registerCapitalStart;
  }
  if (!Util.isUnset(request.registerCapitalTypeShrink)) {
    body['RegisterCapitalType'] = request.registerCapitalTypeShrink;
  }
  if (!Util.isUnset(request.searchNewComp)) {
    body['SearchNewComp'] = request.searchNewComp;
  }
  if (!Util.isUnset(request.spreadInfoShrink)) {
    body['SpreadInfo'] = request.spreadInfoShrink;
  }
  if (!Util.isUnset(request.staffSizeShrink)) {
    body['StaffSize'] = request.staffSizeShrink;
  }
  if (!Util.isUnset(request.taskId)) {
    body['TaskId'] = request.taskId;
  }
  if (!Util.isUnset(request.transformRateShrink)) {
    body['TransformRate'] = request.transformRateShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'QueryCompany',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryCompany(request: QueryCompanyRequest): QueryCompanyResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryCompanyWithOptions(request, runtime);
}

model QueryCompanyConditionRequest {
  conditionType?: string(name='ConditionType'),
}

model QueryCompanyConditionResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model QueryCompanyConditionResponse = {
  headers: map[string]string(name='headers'),
  body: QueryCompanyConditionResponseBody(name='body'),
}

async function queryCompanyConditionWithOptions(request: QueryCompanyConditionRequest, runtime: Util.RuntimeOptions): QueryCompanyConditionResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.conditionType)) {
    query['ConditionType'] = request.conditionType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryCompanyCondition',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryCompanyCondition(request: QueryCompanyConditionRequest): QueryCompanyConditionResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryCompanyConditionWithOptions(request, runtime);
}

model QueryCompanyInfoRequest {
  conditions?: map[string]any(name='Conditions'),
  returnFields?: map[string]any(name='ReturnFields'),
  SQLId?: int32(name='SQLId'),
}

model QueryCompanyInfoShrinkRequest {
  conditionsShrink?: string(name='Conditions'),
  returnFieldsShrink?: string(name='ReturnFields'),
  SQLId?: int32(name='SQLId'),
}

model QueryCompanyInfoResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model QueryCompanyInfoResponse = {
  headers: map[string]string(name='headers'),
  body: QueryCompanyInfoResponseBody(name='body'),
}

async function queryCompanyInfoWithOptions(tmpReq: QueryCompanyInfoRequest, runtime: Util.RuntimeOptions): QueryCompanyInfoResponse {
  Util.validateModel(tmpReq);
  var request = new QueryCompanyInfoShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.conditions)) {
    request.conditionsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.conditions, 'Conditions', 'json');
  }
  if (!Util.isUnset(tmpReq.returnFields)) {
    request.returnFieldsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.returnFields, 'ReturnFields', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.SQLId)) {
    query['SQLId'] = request.SQLId;
  }
  var body : map[string]any= {};
  if (!Util.isUnset(request.conditionsShrink)) {
    body['Conditions'] = request.conditionsShrink;
  }
  if (!Util.isUnset(request.returnFieldsShrink)) {
    body['ReturnFields'] = request.returnFieldsShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'QueryCompanyInfo',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryCompanyInfo(request: QueryCompanyInfoRequest): QueryCompanyInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryCompanyInfoWithOptions(request, runtime);
}

model QueryMultiCorpsRelationshipRequest {
  corpNames?: map[string]any(name='CorpNames'),
  maxPath?: int32(name='MaxPath'),
}

model QueryMultiCorpsRelationshipShrinkRequest {
  corpNamesShrink?: string(name='CorpNames'),
  maxPath?: int32(name='MaxPath'),
}

model QueryMultiCorpsRelationshipResponseBody = {
  code?: int32(name='Code'),
  data?: {
    graphPaths?: [ 
      {
        endNodeName?: string(name='EndNodeName'),
        paths?: [ 
          {
            nodes?: [ 
              {
                id?: string(name='Id'),
                label?: string(name='Label'),
                name?: string(name='Name'),
                properties?: map[string]any(name='Properties'),
              }
            ](name='Nodes'),
            relationLevel?: long(name='RelationLevel'),
            relationRank?: long(name='RelationRank'),
            relationships?: [ 
              {
                endNode?: string(name='EndNode'),
                id?: string(name='Id'),
                name?: string(name='Name'),
                properties?: map[string]any(name='Properties'),
                startNode?: string(name='StartNode'),
                type?: string(name='Type'),
              }
            ](name='Relationships'),
            strength?: float(name='Strength'),
          }
        ](name='Paths'),
        startNodeName?: string(name='StartNodeName'),
      }
    ](name='GraphPaths'),
    group?: int32(name='Group'),
    groupCorps?: [  map[string]any ](name='GroupCorps'),
    pathTotal?: int32(name='PathTotal'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model QueryMultiCorpsRelationshipResponse = {
  headers: map[string]string(name='headers'),
  body: QueryMultiCorpsRelationshipResponseBody(name='body'),
}

async function queryMultiCorpsRelationshipWithOptions(tmpReq: QueryMultiCorpsRelationshipRequest, runtime: Util.RuntimeOptions): QueryMultiCorpsRelationshipResponse {
  Util.validateModel(tmpReq);
  var request = new QueryMultiCorpsRelationshipShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.corpNames)) {
    request.corpNamesShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.corpNames, 'CorpNames', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.maxPath)) {
    query['MaxPath'] = request.maxPath;
  }
  var body : map[string]any= {};
  if (!Util.isUnset(request.corpNamesShrink)) {
    body['CorpNames'] = request.corpNamesShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'QueryMultiCorpsRelationship',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryMultiCorpsRelationship(request: QueryMultiCorpsRelationshipRequest): QueryMultiCorpsRelationshipResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryMultiCorpsRelationshipWithOptions(request, runtime);
}

model QueryRskStatisticRequest {
  endDate?: string(name='EndDate'),
  oneCompId?: map[string]any(name='OneCompId'),
  rskType?: map[string]any(name='RskType'),
  startDate?: string(name='StartDate'),
}

model QueryRskStatisticShrinkRequest {
  endDate?: string(name='EndDate'),
  oneCompIdShrink?: string(name='OneCompId'),
  rskTypeShrink?: string(name='RskType'),
  startDate?: string(name='StartDate'),
}

model QueryRskStatisticResponseBody = {
  code?: int32(name='Code'),
  data?: [ 
    {
      corpName?: string(name='CorpName'),
      count?: long(name='Count'),
      ocId?: string(name='OcId'),
      type?: string(name='Type'),
      updateDate?: string(name='UpdateDate'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model QueryRskStatisticResponse = {
  headers: map[string]string(name='headers'),
  body: QueryRskStatisticResponseBody(name='body'),
}

async function queryRskStatisticWithOptions(tmpReq: QueryRskStatisticRequest, runtime: Util.RuntimeOptions): QueryRskStatisticResponse {
  Util.validateModel(tmpReq);
  var request = new QueryRskStatisticShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.oneCompId)) {
    request.oneCompIdShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.oneCompId, 'OneCompId', 'json');
  }
  if (!Util.isUnset(tmpReq.rskType)) {
    request.rskTypeShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.rskType, 'RskType', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.endDate)) {
    query['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.oneCompIdShrink)) {
    query['OneCompId'] = request.oneCompIdShrink;
  }
  if (!Util.isUnset(request.rskTypeShrink)) {
    query['RskType'] = request.rskTypeShrink;
  }
  if (!Util.isUnset(request.startDate)) {
    query['StartDate'] = request.startDate;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryRskStatistic',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryRskStatistic(request: QueryRskStatisticRequest): QueryRskStatisticResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryRskStatisticWithOptions(request, runtime);
}

model SearchCompanyRequest {
  account?: string(name='Account'),
  bizCategories?: map[string]any(name='BizCategories'),
  bizInfo?: map[string]any(name='BizInfo'),
  bizScopeKeyword?: map[string]any(name='BizScopeKeyword'),
  bizStatus?: map[string]any(name='BizStatus'),
  bizType?: map[string]any(name='BizType'),
  brandInfo?: map[string]any(name='BrandInfo'),
  buildTime?: map[string]any(name='BuildTime'),
  companyType?: map[string]any(name='CompanyType'),
  corpName?: string(name='CorpName'),
  goodsCorpType?: string(name='GoodsCorpType'),
  goodsList?: string(name='GoodsList'),
  keyword?: string(name='Keyword'),
  licenseNumber?: string(name='LicenseNumber'),
  lifecycle?: map[string]any(name='Lifecycle'),
  limit?: int32(name='Limit'),
  newCorp?: string(name='NewCorp'),
  offset?: int32(name='Offset'),
  orderBy?: map[string]any(name='OrderBy'),
  orgNo?: string(name='OrgNo'),
  productShopMatch?: string(name='ProductShopMatch'),
  recCap?: string(name='RecCap'),
  region?: map[string]any(name='Region'),
  regions?: map[string]any(name='Regions'),
  registerAssert?: map[string]any(name='RegisterAssert'),
  spreadInfo?: map[string]any(name='SpreadInfo'),
  staffSize?: map[string]any(name='StaffSize'),
}

model SearchCompanyShrinkRequest {
  account?: string(name='Account'),
  bizCategoriesShrink?: string(name='BizCategories'),
  bizInfoShrink?: string(name='BizInfo'),
  bizScopeKeywordShrink?: string(name='BizScopeKeyword'),
  bizStatusShrink?: string(name='BizStatus'),
  bizTypeShrink?: string(name='BizType'),
  brandInfoShrink?: string(name='BrandInfo'),
  buildTimeShrink?: string(name='BuildTime'),
  companyTypeShrink?: string(name='CompanyType'),
  corpName?: string(name='CorpName'),
  goodsCorpType?: string(name='GoodsCorpType'),
  goodsList?: string(name='GoodsList'),
  keyword?: string(name='Keyword'),
  licenseNumber?: string(name='LicenseNumber'),
  lifecycleShrink?: string(name='Lifecycle'),
  limit?: int32(name='Limit'),
  newCorp?: string(name='NewCorp'),
  offset?: int32(name='Offset'),
  orderByShrink?: string(name='OrderBy'),
  orgNo?: string(name='OrgNo'),
  productShopMatch?: string(name='ProductShopMatch'),
  recCap?: string(name='RecCap'),
  regionShrink?: string(name='Region'),
  regionsShrink?: string(name='Regions'),
  registerAssertShrink?: string(name='RegisterAssert'),
  spreadInfoShrink?: string(name='SpreadInfo'),
  staffSizeShrink?: string(name='StaffSize'),
}

model SearchCompanyResponseBody = {
  code?: int32(name='Code'),
  data?: [  map[string]any ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model SearchCompanyResponse = {
  headers: map[string]string(name='headers'),
  body: SearchCompanyResponseBody(name='body'),
}

async function searchCompanyWithOptions(tmpReq: SearchCompanyRequest, runtime: Util.RuntimeOptions): SearchCompanyResponse {
  Util.validateModel(tmpReq);
  var request = new SearchCompanyShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.bizCategories)) {
    request.bizCategoriesShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.bizCategories, 'BizCategories', 'json');
  }
  if (!Util.isUnset(tmpReq.bizInfo)) {
    request.bizInfoShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.bizInfo, 'BizInfo', 'json');
  }
  if (!Util.isUnset(tmpReq.bizScopeKeyword)) {
    request.bizScopeKeywordShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.bizScopeKeyword, 'BizScopeKeyword', 'json');
  }
  if (!Util.isUnset(tmpReq.bizStatus)) {
    request.bizStatusShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.bizStatus, 'BizStatus', 'json');
  }
  if (!Util.isUnset(tmpReq.bizType)) {
    request.bizTypeShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.bizType, 'BizType', 'json');
  }
  if (!Util.isUnset(tmpReq.brandInfo)) {
    request.brandInfoShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.brandInfo, 'BrandInfo', 'json');
  }
  if (!Util.isUnset(tmpReq.buildTime)) {
    request.buildTimeShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.buildTime, 'BuildTime', 'json');
  }
  if (!Util.isUnset(tmpReq.companyType)) {
    request.companyTypeShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.companyType, 'CompanyType', 'json');
  }
  if (!Util.isUnset(tmpReq.lifecycle)) {
    request.lifecycleShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.lifecycle, 'Lifecycle', 'json');
  }
  if (!Util.isUnset(tmpReq.orderBy)) {
    request.orderByShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.orderBy, 'OrderBy', 'json');
  }
  if (!Util.isUnset(tmpReq.region)) {
    request.regionShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.region, 'Region', 'json');
  }
  if (!Util.isUnset(tmpReq.regions)) {
    request.regionsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.regions, 'Regions', 'json');
  }
  if (!Util.isUnset(tmpReq.registerAssert)) {
    request.registerAssertShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.registerAssert, 'RegisterAssert', 'json');
  }
  if (!Util.isUnset(tmpReq.spreadInfo)) {
    request.spreadInfoShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.spreadInfo, 'SpreadInfo', 'json');
  }
  if (!Util.isUnset(tmpReq.staffSize)) {
    request.staffSizeShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.staffSize, 'StaffSize', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.account)) {
    query['Account'] = request.account;
  }
  if (!Util.isUnset(request.corpName)) {
    query['CorpName'] = request.corpName;
  }
  if (!Util.isUnset(request.goodsCorpType)) {
    query['GoodsCorpType'] = request.goodsCorpType;
  }
  if (!Util.isUnset(request.goodsList)) {
    query['GoodsList'] = request.goodsList;
  }
  if (!Util.isUnset(request.keyword)) {
    query['Keyword'] = request.keyword;
  }
  if (!Util.isUnset(request.licenseNumber)) {
    query['LicenseNumber'] = request.licenseNumber;
  }
  if (!Util.isUnset(request.limit)) {
    query['Limit'] = request.limit;
  }
  if (!Util.isUnset(request.newCorp)) {
    query['NewCorp'] = request.newCorp;
  }
  if (!Util.isUnset(request.offset)) {
    query['Offset'] = request.offset;
  }
  if (!Util.isUnset(request.orgNo)) {
    query['OrgNo'] = request.orgNo;
  }
  if (!Util.isUnset(request.productShopMatch)) {
    query['ProductShopMatch'] = request.productShopMatch;
  }
  if (!Util.isUnset(request.recCap)) {
    query['RecCap'] = request.recCap;
  }
  var body : map[string]any= {};
  if (!Util.isUnset(request.bizCategoriesShrink)) {
    body['BizCategories'] = request.bizCategoriesShrink;
  }
  if (!Util.isUnset(request.bizInfoShrink)) {
    body['BizInfo'] = request.bizInfoShrink;
  }
  if (!Util.isUnset(request.bizScopeKeywordShrink)) {
    body['BizScopeKeyword'] = request.bizScopeKeywordShrink;
  }
  if (!Util.isUnset(request.bizStatusShrink)) {
    body['BizStatus'] = request.bizStatusShrink;
  }
  if (!Util.isUnset(request.bizTypeShrink)) {
    body['BizType'] = request.bizTypeShrink;
  }
  if (!Util.isUnset(request.brandInfoShrink)) {
    body['BrandInfo'] = request.brandInfoShrink;
  }
  if (!Util.isUnset(request.buildTimeShrink)) {
    body['BuildTime'] = request.buildTimeShrink;
  }
  if (!Util.isUnset(request.companyTypeShrink)) {
    body['CompanyType'] = request.companyTypeShrink;
  }
  if (!Util.isUnset(request.lifecycleShrink)) {
    body['Lifecycle'] = request.lifecycleShrink;
  }
  if (!Util.isUnset(request.orderByShrink)) {
    body['OrderBy'] = request.orderByShrink;
  }
  if (!Util.isUnset(request.regionShrink)) {
    body['Region'] = request.regionShrink;
  }
  if (!Util.isUnset(request.regionsShrink)) {
    body['Regions'] = request.regionsShrink;
  }
  if (!Util.isUnset(request.registerAssertShrink)) {
    body['RegisterAssert'] = request.registerAssertShrink;
  }
  if (!Util.isUnset(request.spreadInfoShrink)) {
    body['SpreadInfo'] = request.spreadInfoShrink;
  }
  if (!Util.isUnset(request.staffSizeShrink)) {
    body['StaffSize'] = request.staffSizeShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SearchCompany',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function searchCompany(request: SearchCompanyRequest): SearchCompanyResponse {
  var runtime = new Util.RuntimeOptions{};
  return searchCompanyWithOptions(request, runtime);
}

model SearchCorpByKeywordRequest {
  account?: string(name='Account'),
  keyword?: string(name='Keyword'),
  limit?: int32(name='Limit'),
  offset?: int32(name='Offset'),
}

model SearchCorpByKeywordResponseBody = {
  code?: int32(name='Code'),
  data?: [ string ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  total?: int32(name='Total'),
}

model SearchCorpByKeywordResponse = {
  headers: map[string]string(name='headers'),
  body: SearchCorpByKeywordResponseBody(name='body'),
}

async function searchCorpByKeywordWithOptions(request: SearchCorpByKeywordRequest, runtime: Util.RuntimeOptions): SearchCorpByKeywordResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.account)) {
    query['Account'] = request.account;
  }
  if (!Util.isUnset(request.keyword)) {
    query['Keyword'] = request.keyword;
  }
  if (!Util.isUnset(request.limit)) {
    query['Limit'] = request.limit;
  }
  if (!Util.isUnset(request.offset)) {
    query['Offset'] = request.offset;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SearchCorpByKeyword',
    version = '2020-04-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function searchCorpByKeyword(request: SearchCorpByKeywordRequest): SearchCorpByKeywordResponse {
  var runtime = new Util.RuntimeOptions{};
  return searchCorpByKeywordWithOptions(request, runtime);
}

